home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Magazine / GraphicsCards / StormMesa / src-glut / layerutil.c < prev    next >
C/C++ Source or Header  |  1998-12-15  |  6KB  |  202 lines
  1.  
  2. /* Copyright (c) Mark J. Kilgard, 1993, 1994. */
  3.  
  4. /* This program is freely distributable without licensing fees
  5.    and is provided without guarantee or warrantee expressed or
  6.    implied. This program is -not- in the public domain. */
  7.  
  8. /* Based on XLayerUtil.c: Revision: 1.5 */
  9.  
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include "layerutil.h"
  13.  
  14. /* SGI optimization introduced in IRIX 6.3 to avoid X server
  15.    round trips for interning common X atoms. */
  16. #include <X11/Xatom.h>
  17. #if defined(_SGI_EXTRA_PREDEFINES) && !defined(NO_FAST_ATOMS)
  18. #include <X11/SGIFastAtom.h>
  19. #else
  20. #define XSGIFastInternAtom(dpy,string,fast_name,how) XInternAtom(dpy,string,how)
  21. #endif
  22.  
  23. static Bool layersRead = False;
  24. static OverlayInfo **overlayInfoPerScreen;
  25. static unsigned long *numOverlaysPerScreen;
  26.  
  27. static void
  28. findServerOverlayVisualsInfo(Display * dpy)
  29. {
  30.   static Atom overlayVisualsAtom;
  31.   Atom actualType;
  32.   Status status;
  33.   unsigned long sizeData, bytesLeft;
  34.   Window root;
  35.   int actualFormat, numScreens, i;
  36.  
  37.   if (layersRead == False) {
  38.     overlayVisualsAtom = XSGIFastInternAtom(dpy,
  39.       "SERVER_OVERLAY_VISUALS", SGI_XA_SERVER_OVERLAY_VISUALS, True);
  40.     if (overlayVisualsAtom != None) {
  41.       numScreens = ScreenCount(dpy);
  42.       overlayInfoPerScreen = (OverlayInfo **)
  43.         malloc(numScreens * sizeof(OverlayInfo *));
  44.       numOverlaysPerScreen = (unsigned long *)
  45.         malloc(numScreens * sizeof(unsigned long));
  46.       if (overlayInfoPerScreen != NULL &&
  47.         numOverlaysPerScreen != NULL) {
  48.         for (i = 0; i < numScreens; i++) {
  49.           root = RootWindow(dpy, i);
  50.           status = XGetWindowProperty(dpy, root,
  51.             overlayVisualsAtom, 0L, (long) 10000, False,
  52.             overlayVisualsAtom, &actualType, &actualFormat,
  53.             &sizeData, &bytesLeft,
  54.             (unsigned char **) &overlayInfoPerScreen[i]);
  55.           if (status != Success ||
  56.             actualType != overlayVisualsAtom ||
  57.             actualFormat != 32 || sizeData < 4)
  58.             numOverlaysPerScreen[i] = 0;
  59.           else
  60.             /* Four 32-bit quantities per
  61.                SERVER_OVERLAY_VISUALS entry. */
  62.             numOverlaysPerScreen[i] = sizeData / 4;
  63.         }
  64.         layersRead = True;
  65.       } else {
  66.         if (overlayInfoPerScreen != NULL)
  67.           free(overlayInfoPerScreen);
  68.         if (numOverlaysPerScreen != NULL)
  69.           free(numOverlaysPerScreen);
  70.       }
  71.     }
  72.   }
  73. }
  74.  
  75. int
  76. __glutGetTransparentPixel(Display * dpy, XVisualInfo * vinfo)
  77. {
  78.   int i, screen = vinfo->screen;
  79.   OverlayInfo *overlayInfo;
  80.  
  81.   findServerOverlayVisualsInfo(dpy);
  82.   if (layersRead) {
  83.     for (i = 0; i < numOverlaysPerScreen[screen]; i++) {
  84.       overlayInfo = &overlayInfoPerScreen[screen][i];
  85.       if (vinfo->visualid == overlayInfo->overlay_visual) {
  86.         if (overlayInfo->transparent_type == TransparentPixel) {
  87.           return (int) overlayInfo->value;
  88.         } else {
  89.           return -1;
  90.         }
  91.       }
  92.     }
  93.   }
  94.   return -1;
  95. }
  96.  
  97. XLayerVisualInfo *
  98. __glutXGetLayerVisualInfo(Display * dpy, long lvinfo_mask,
  99.   XLayerVisualInfo * lvinfo_template, int *nitems_return)
  100. {
  101.   XVisualInfo *vinfo;
  102.   XLayerVisualInfo *layerInfo;
  103.   int numVisuals, count, i, j;
  104.  
  105.   vinfo = XGetVisualInfo(dpy, lvinfo_mask & VisualAllMask,
  106.     &lvinfo_template->vinfo, nitems_return);
  107.   if (vinfo == NULL)
  108.     return NULL;
  109.   numVisuals = *nitems_return;
  110.   findServerOverlayVisualsInfo(dpy);
  111.   layerInfo = (XLayerVisualInfo *)
  112.     malloc(numVisuals * sizeof(XLayerVisualInfo));
  113.   if (layerInfo == NULL) {
  114.     XFree(vinfo);
  115.     return NULL;
  116.   }
  117.   count = 0;
  118.   for (i = 0; i < numVisuals; i++) {
  119.     XVisualInfo *pVinfo = &vinfo[i];
  120.     int screen = pVinfo->screen;
  121.     OverlayInfo *overlayInfo = NULL;
  122.  
  123.     overlayInfo = NULL;
  124.     if (layersRead) {
  125.       for (j = 0; j < numOverlaysPerScreen[screen]; j++)
  126.         if (pVinfo->visualid ==
  127.           overlayInfoPerScreen[screen][j].overlay_visual) {
  128.           overlayInfo = &overlayInfoPerScreen[screen][j];
  129.           break;
  130.         }
  131.     }
  132.     if (lvinfo_mask & VisualLayerMask)
  133.       if (overlayInfo == NULL) {
  134.         if (lvinfo_template->layer != 0)
  135.           continue;
  136.       } else if (lvinfo_template->layer != overlayInfo->layer)
  137.         continue;
  138.     if (lvinfo_mask & VisualTransparentType)
  139.       if (overlayInfo == NULL) {
  140.         if (lvinfo_template->type != None)
  141.           continue;
  142.       } else if (lvinfo_template->type !=
  143.         overlayInfo->transparent_type)
  144.         continue;
  145.     if (lvinfo_mask & VisualTransparentValue)
  146.       if (overlayInfo == NULL)
  147.         /* Non-overlay visuals have no sense of
  148.            TransparentValue. */
  149.         continue;
  150.       else if (lvinfo_template->value != overlayInfo->value)
  151.         continue;
  152.     layerInfo[count].vinfo = *pVinfo;
  153.     if (overlayInfo == NULL) {
  154.       layerInfo[count].layer = 0;
  155.       layerInfo[count].type = None;
  156.       layerInfo[count].value = 0;  /* meaningless */
  157.     } else {
  158.       layerInfo[count].layer = overlayInfo->layer;
  159.       layerInfo[count].type = overlayInfo->transparent_type;
  160.       layerInfo[count].value = overlayInfo->value;
  161.     }
  162.     count++;
  163.   }
  164.   XFree(vinfo);
  165.   *nitems_return = count;
  166.   if (count == 0) {
  167.     XFree(layerInfo);
  168.     return NULL;
  169.   } else
  170.     return layerInfo;
  171. }
  172.  
  173. #if 0                   /* Unused by GLUT. */
  174. Status
  175. __glutXMatchLayerVisualInfo(Display * dpy, int screen,
  176.   int depth, int visualClass, int layer,
  177.   XLayerVisualInfo * lvinfo_return)
  178. {
  179.   XLayerVisualInfo *lvinfo;
  180.   XLayerVisualInfo lvinfoTemplate;
  181.   int nitems;
  182.  
  183.   lvinfoTemplate.vinfo.screen = screen;
  184.   lvinfoTemplate.vinfo.depth = depth;
  185. #if defined(__cplusplus) || defined(c_plusplus)
  186.   lvinfoTemplate.vinfo.c_class = visualClass;
  187. #else
  188.   lvinfoTemplate.vinfo.class = visualClass;
  189. #endif
  190.   lvinfoTemplate.layer = layer;
  191.   lvinfo = __glutXGetLayerVisualInfo(dpy,
  192.     VisualScreenMask | VisualDepthMask |
  193.     VisualClassMask | VisualLayerMask,
  194.     &lvinfoTemplate, &nitems);
  195.   if (lvinfo != NULL && nitems > 0) {
  196.     *lvinfo_return = *lvinfo;
  197.     return 1;
  198.   } else
  199.     return 0;
  200. }
  201. #endif
  202.